home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / WindowPort.C < prev    next >
C/C++ Source or Header  |  1990-12-05  |  16KB  |  753 lines
  1. //$WindowPort$
  2. #include "WindowPort.h"
  3. #include "Error.h"
  4. #include "System.h"
  5. #include "WindowSystem.h"
  6. #include "Math.h"
  7. #include "Storage.h"
  8.  
  9. const int MaxInvals= 20;
  10.  
  11. extern bool fullscreen;
  12. extern bool gBatch;
  13.  
  14. WindowPort *focusport;
  15. u_long lasttime;
  16. int Clicks;
  17.  
  18. static Token lastClick;
  19. static WindowPort *grabport;
  20.  
  21. //---- WindowPort --------------------------------------------------------------
  22.  
  23. MetaImpl0(WindowPort);
  24.  
  25. WindowPort::WindowPort(InpHandlerFun ih, void *p1, bool ov, bool bl, bool)
  26. {
  27.     ihf= ih;
  28.     privdata= p1;
  29.     overlay= ov;
  30.     block= bl;
  31.     state= eWsHidden;
  32.     cursor= eCrsBoldArrow;
  33.     hascolor= gColor;
  34.     
  35.     done= FALSE;
  36.     havepushbacktoken= FALSE;
  37.     
  38.     if (invalRects == 0)
  39.     invalRects= new Rectangle[MaxInvals];
  40.     inval= 0;
  41. }
  42.  
  43. WindowPort::~WindowPort()
  44. {
  45.     if (focusport == this)
  46.     focusport= 0;
  47.     if (state == eWsClosed)
  48.     return;
  49.     state= eWsClosed;
  50.     SafeDelete(invalRects);
  51.     gWindowSystem->RemoveWindow(this);
  52. }
  53.  
  54. void WindowPort::InvalidateRect(Rectangle r)
  55. {
  56.     if (inval == 0) {
  57.     invalRects[inval++]= invalBounds= r;
  58.     return;
  59.     }
  60.     invalBounds.Merge(r);
  61.     for (int i= 0; i < inval; i++) {
  62.     if (invalRects[i].ContainsRect(r))
  63.         return;
  64.     if (r.ContainsRect(invalRects[i])) {
  65.         invalRects[i]= r;
  66.         return;
  67.     } 
  68.     if (r.Intersects(invalRects[i])) {
  69.         invalRects[i].Merge(r);
  70.         return;
  71.     }
  72.     }
  73.     if (inval >= MaxInvals)
  74.     invalRects[inval-1].Merge(r);
  75.     else
  76.     invalRects[inval++]= r;
  77. }
  78.  
  79. //---- cursor stuff ------------------------------------------------------------
  80.  
  81. GrCursor WindowPort::SetCursor(GrCursor c)
  82. {
  83.     if (c != cursor && c >= eCrsNone && c <= eCrsUpDownArrow) {
  84.     GrCursor oldc= cursor;
  85.     cursor= c;
  86.     DevSetCursor(c);
  87.     GiveHint(eHintFlush, 0, 0);
  88.     return oldc;
  89.     }
  90.     return c;
  91. }
  92.  
  93. GrCursor WindowPort::GetCursor()
  94. {
  95.     return cursor;
  96. }
  97.  
  98. GrCursor WindowPort::SetWaitCursor(unsigned int, GrCursor c)
  99. {
  100.     return SetCursor(c);
  101. }
  102.  
  103. //---- input handling ----------------------------------------------------------
  104.  
  105. void WindowPort::GetEvent(Token *t, int timeout, bool overread)
  106. {
  107.     if (havepushbacktoken) {
  108.     *t= pushbacktoken;
  109.     havepushbacktoken= FALSE;
  110.     } else
  111.     DevGetEvent(t, timeout, overread);
  112.     
  113.     if (t->Code != eEvtDamage && t->Code != eEvtNone && t->Code != eEvtIdle) {
  114.     if (t->Code != eEvtEnter && t->Code != eEvtExit)
  115.         lastpos= t->Pos;
  116.     lasttime= t->At;
  117.     } else if (t->Code == eEvtNone) {
  118.     t->Pos= lastpos;
  119.     t->At= lasttime;
  120.     }
  121. };
  122.  
  123. void WindowPort::SendInput(Token *t)
  124. {
  125.     if (state != eWsShown)
  126.     return;
  127.     
  128.     if (t->Code != eEvtDamage && t->Code != eEvtNone && t->Code != eEvtIdle) {
  129.     if (t->Code != eEvtEnter && t->Code != eEvtExit)
  130.         lastpos= t->Pos;
  131.     lasttime= t->At;
  132.     } else if (t->Code == eEvtNone) {
  133.     t->Flags= 0;
  134.     t->Pos= lastpos;
  135.     t->At= lasttime;
  136.     }
  137.     
  138.     WindowPort *wp= grabport;
  139.  
  140.     if (t->IsKey() && t->Flags == (eFlgShiftKey|eFlgCntlKey|eFlgMetaKey)
  141.                          && t->MapToAscii() == 'u')
  142.     Exit(1, FALSE);
  143.     
  144.     switch (t->Code) {
  145.     case eEvtEnter:
  146.     focusport= this;
  147.     break;
  148.     case eEvtExit:
  149.     focusport= 0;
  150.     break;
  151.     }
  152.     if (wp && (wp != this)) {
  153.     switch (t->Code) {
  154.     case eEvtIdle:
  155.     case eEvtNone:
  156.     case eEvtLocMove:
  157.     case eEvtLocMoveBut:
  158.     case eEvtLocStill:
  159.     case eEvtEnter:
  160.         // ignore events
  161.         return;
  162.     case eEvtExit:
  163.     case eEvtDamage:
  164.         // allow damages
  165.         break;
  166.     default:
  167.         wp->Bell(50);
  168.         return;
  169.     }  
  170.     }
  171.     switch (t->Code) {
  172.     case eEvtDamage:
  173.     switch (t->Flags) {
  174.     case eFlgDamage1:
  175.         InvalidateRect(t->ext);
  176.         break;
  177.     case eFlgDamage2:
  178.         InvalidateRect(t->DamageRect());
  179.         break;
  180.     case eFlgDamage3:
  181.         InvalidateRect(t->DamageRect());
  182.         return;
  183.     }
  184.     break;
  185.     default:
  186.     if (t->IsMouseButton()) {
  187.         if (lastClick.DoubleClick(*t))
  188.         Clicks++;
  189.         else
  190.         Clicks= 1;
  191.         lastClick= *t;
  192.     }
  193.     break;
  194.     }
  195.     (*ihf)(privdata, t);
  196. }
  197.  
  198. void WindowPort::PushEvent(Token t)
  199. {
  200.     if (t.Code != eEvtNone) {
  201.     pushbacktoken= t;
  202.     havepushbacktoken= TRUE;
  203.     }
  204. }
  205.  
  206. void WindowPort::Damage(EventFlags f, Rectangle *r)
  207. {
  208.     Token dt(f, *r);
  209.     dt.Dump();
  210.     SendInput(&dt);
  211. }
  212.         
  213. //---- window management -------------------------------------------------------
  214.  
  215. void WindowPort::Hide()
  216. {
  217.     if (state != eWsShown)
  218.     return;
  219.     state= eWsHidden;
  220.     
  221.     inval= 0;
  222.     
  223.     FlushAnyText();
  224.     
  225.     if (grabport || block)
  226.     done= TRUE;
  227.     else
  228.     DevHide1();
  229. };
  230.  
  231. void WindowPort::Show(WindowPort *father, Rectangle r)
  232. {
  233.     Point delta;
  234.     Rectangle rr= r;
  235.     
  236.     if (state != eWsHidden)
  237.     return;
  238.     state= eWsShown;
  239.     
  240.     inval= 0;
  241.     
  242.     FlushAnyText();
  243.  
  244.     if (father)
  245.     rr.origin+= father->GetRect().origin;
  246.     else if (r.origin == gPoint_1)
  247.     r.origin= Half(gScreenRect.extent - r.extent);
  248.     delta= rr.AmountToTranslateWithin(gScreenRect);
  249.     rr.origin+= delta;
  250.     
  251.     DevShow1(father, rr);
  252.     
  253.     if (grabport || block) {
  254.     WindowPort *oldgrabport= grabport;
  255.     grabport= this;
  256.     if (delta != gPoint0)
  257.         MoveMousePos(delta);
  258.     done= FALSE;
  259.     if (havepushbacktoken) {
  260.         havepushbacktoken= FALSE;
  261.         SendInput(&pushbacktoken);
  262.     }
  263.     while (! done)
  264.         gSystem->InnerLoop();
  265.     DevHide1();
  266.     grabport= oldgrabport;
  267.     }
  268. };
  269.  
  270. void WindowPort::DevHide1()
  271. {
  272.     state= eWsHidden;
  273.     DevHide();
  274.     GiveHint(eHintFlush, 0, 0);      
  275. }
  276.  
  277. void WindowPort::DevShow1(WindowPort *father, Rectangle r)
  278. {
  279.     state= eWsShown;
  280.     DevShow(father, r);
  281.     GiveHint(eHintFlush, 0, 0);      
  282. }
  283.  
  284. void WindowPort::Grab(bool g, bool fs)
  285. {
  286.     if (fs) {
  287.     FlushAnyText();
  288.     fullscreen= g;
  289.     if (g)   // make sure that clipping is turned off
  290.         Clip(gRect0, gPoint0);
  291.     }
  292.     DevGrab(g, fs);
  293. }
  294.  
  295. Rectangle WindowPort::GetRect()
  296. {
  297.     return DevGetRect();
  298. }
  299.  
  300. void WindowPort::SetOrigin(Point o)
  301. {
  302.     DevSetOrigin(o);
  303. }
  304.  
  305. void WindowPort::SetExtent(Point e)
  306. {
  307.     DevSetExtent(e);
  308. }
  309.  
  310. //---- graphic functions -------------------------------------------------------
  311.  
  312. void WindowPort::ScrollRect(Rectangle r, Point delta)
  313. {
  314.     Rectangle r1, rl[4];
  315.     register int i, n;
  316.     
  317.     FlushMyText();
  318.     r+= origin;
  319.     r.Clip(cliprect);
  320.     r1= r + delta;
  321.     n= Difference(rl, r, r1);
  322.     for (i= 0; i < n; i++)
  323.     InvalidateRect(rl[i]);
  324.     if (r.Clip(r1))
  325.     DevScrollRect(r, delta);
  326. }
  327.  
  328. bool WindowPort::DevImageCacheBegin(ImageCache *bb, Rectangle r)
  329. {
  330.     if (gBatch) {
  331.     FlushMyText();
  332.     r.origin += origin;
  333.     if (r.Clip(cliprect)) {
  334.         r.origin -= origin;
  335.         bb->r= r;
  336.         if (bb->invalid || !bb->vr.ContainsRect(r)) {
  337.         bb->vr= r;
  338.         if (bb->b == 0)
  339.             bb->b= new Bitmap(r.extent, gDepth);
  340.         return TRUE;
  341.         }
  342.     }
  343.     r.origin += origin;
  344.     DevImageCacheCopy2(bb->b->GetDevBitmap(), &r, bb->r.origin - bb->vr.origin);
  345.     return FALSE;
  346.     }
  347.     return TRUE;
  348. }
  349.  
  350. void WindowPort::DevImageCacheEnd(ImageCache *bb)
  351. {
  352.     if (gBatch) {
  353.     Rectangle r= bb->vr;
  354.     r.origin += origin;
  355.     if (bb->b == 0)
  356.         bb->b= new Bitmap(r.extent, gDepth);
  357.     DevImageCacheEnd2(bb->b->GetDevBitmap(), &r);
  358.     bb->invalid= FALSE;
  359.     }
  360. }
  361.  
  362. //---- window system independent graphic methods -------------------------------
  363.  
  364. Point WindowPort::DrawArrow(int psz, Point s, Point e)
  365. {
  366.     int arrowwidth= max(6, psz*4+2), arrowlen= max(9, psz*7);
  367.     Point c, pts[3], ee(arrowwidth/2, arrowlen);
  368.     
  369.     if (Length(e-s) < arrowlen)
  370.     return e;     // too short, give up
  371.  
  372.     double ph= Phi(e-s), rot= Phi(ee), hyp= Length(ee);
  373.  
  374.     pts[0]= e;
  375. #ifdef PETERFIX
  376. // special case: going straight down
  377.     pts[1]= e + Point(-(arrowwidth/2),-arrowlen);
  378.     pts[2]= e + Point(arrowwidth/2,-arrowlen);
  379. #else
  380.     pts[1]= e + PolarToPoint(ph+rot, hyp, hyp);
  381.     pts[2]= e + PolarToPoint(ph-rot, hyp, hyp);
  382. #endif
  383.     c= Half(pts[1]+pts[2]);
  384.     
  385.     Rectangle rr= BoundingBox(3, pts);
  386.     DevFillPolygon2(&rr, pts, 3, ePolyDefault);
  387.     
  388.     return c;
  389. }
  390.  
  391. void WindowPort::DevStrokeLine(int psz, Rectangle *r,
  392.                     GrLineCap cap, Point start, Point end)
  393. {
  394.     if (cap & eStartArrow)
  395.     start= DrawArrow(psz, end, start);
  396.     if (cap & eEndArrow)
  397.     end= DrawArrow(psz, start, end);
  398.     DevStrokeLine2(psz, r, cap, start, end);
  399. }
  400.  
  401. void WindowPort::DevStrokeRect(int psz, Rectangle *r)
  402. {
  403.     int rpsz= (psz <= 0) ? 1 : psz;
  404.     
  405.     rpsz*= 2;
  406.     if (rpsz >= r->extent.x || rpsz >= r->extent.y)
  407.     DevFillRect(r);
  408.     else
  409.     DevStrokeRect2(psz, r);
  410. }
  411.  
  412. //---- splines -----------------------------------------------------------------
  413.  
  414. /*
  415.  * bez: Subdivide a Bezier spline, until it is thin enough to be
  416.  *      considered a line. Store line point in static array points.
  417. */
  418.  
  419. #define FIX(a) (((int) (a)) << 16)
  420. #define INT(a) (((a) + (1 << 15)) >> 16 )
  421. #define DELTA 1
  422.  
  423. static void bez(Point **gPp, int x0, int y0, int x1, int y1, int x2, int y2, int x3, int y3)
  424. {
  425.     int maxx= max(x0, x3), minx= min(x0, x3), maxy= max(y0, y3), miny= min(y0, y3);
  426.     register int tx, ty;
  427.     
  428.     if (x1 >= minx && x1 <= maxx && y1 >= miny && y1 <= maxy
  429.         && x2 >= minx && x2 <= maxx && y2 >= miny && y2 <= maxy) {
  430.     register int ax, ay, dx= INT(x3-x0), dy= INT(y3-y0);
  431.     if (dx == 0 || dy == 0) {
  432.         (*gPp)->x= INT(x3);
  433.         (*gPp)++->y= INT(y3);
  434.         return;
  435.     }
  436.     ax= ((dy*INT(x1-x0))/dx)+INT(y0-y1);
  437.     ay= ((dx*INT(y1-y0))/dy)+INT(x0-x1);
  438.     if (abs(ax*ay) <= DELTA) {
  439.         (*gPp)->x= INT(x3);
  440.         (*gPp)++->y= INT(y3);
  441.         return;
  442.     }
  443.     ax= ((dy*INT(x2-x0))/dx)+INT(y0-y2);
  444.     ay= ((dx*INT(y2-y0))/dy)+INT(x0-x2);
  445.     if (abs(ax*ay) <= DELTA) {
  446.         (*gPp)->x= INT(x3);
  447.         (*gPp)++->y= INT(y3);
  448.         return;
  449.     }
  450.     }
  451.     
  452.     tx = (x0 >> 3) + 3 * (x1 >> 3) + 3 * (x2 >> 3) + (x3 >> 3);
  453.     ty = (y0 >> 3) + 3 * (y1 >> 3) + 3 * (y2 >> 3) + (y3 >> 3);
  454.     bez(gPp, x0, y0, (x0 >> 1) + (x1 >> 1), (y0 >> 1) + (y1 >> 1),
  455.         (x0 >> 2) + (x1 >> 1) + (x2 >> 2),
  456.         (y0 >> 2) + (y1 >> 1) + (y2 >> 2),
  457.         tx, ty);
  458.     bez(gPp, tx, ty, (x3 >> 2) + (x2 >> 1) + (x1 >> 2),
  459.         (y3 >> 2) + (y2 >> 1) + (y1 >> 2),
  460.         (x3 >> 1) + (x2 >> 1), (y3 >> 1) + (y2 >> 1),
  461.         x3, y3);
  462. }
  463.  
  464. static int makespline(Point *pts, Point *p, int n, GrPolyType)
  465. {
  466.     register int i;
  467.     Point *gPp= pts;
  468.     
  469.     gPp->x= p[0].x;
  470.     (gPp++)->y= p[0].y;
  471.     for (i= 0; i < n-1; i+= 3)
  472.     bez(&gPp, FIX(p[i+0].x), FIX(p[i+0].y), FIX(p[i+1].x), FIX(p[i+1].y),
  473.          FIX(p[i+2].x), FIX(p[i+2].y), FIX(p[i+3].x), FIX(p[i+3].y));
  474.     
  475.     return gPp - pts;
  476. }
  477.  
  478. void WindowPort::DevStrokePolygon(Rectangle *r,
  479.         Point *pts, int npts, GrPolyType t, int psz, GrLineCap cap)
  480. {
  481.     Point *tmppts= 0;
  482.     
  483.     if (cap & eStartArrow)
  484.     DrawArrow(psz, pts[1]+r->origin, pts[0]+r->origin);
  485.     if (cap & eEndArrow)
  486.     DrawArrow(psz, pts[npts-2]+r->origin, pts[npts-1]+r->origin);
  487.     if (t & ePolyBezier) {
  488.     tmppts= (Point*) Alloca(sizeof(Point) * npts * 30);
  489.     int nn= makespline(tmppts, pts, npts, t);
  490.     if (nn > 0) {
  491.         pts= tmppts;
  492.         npts= nn;
  493.     }
  494.     }
  495.     DevStrokePolygon2(r, pts, npts, ePolyDefault, psz, cap);
  496.     Freea(tmppts);
  497. }
  498.  
  499. void WindowPort::DevFillPolygon(Rectangle *r, Point *pts, int npts, GrPolyType t)
  500. {
  501.     Point *tmppts= 0;
  502.     if (t & ePolyBezier) {
  503.     tmppts= (Point*) Alloca(sizeof(Point) * npts * 30);
  504.     int nn= makespline(tmppts, pts, npts, t);
  505.     if (nn > 0) {
  506.         pts= tmppts;
  507.         npts= nn;
  508.     }
  509.     }
  510.     DevFillPolygon2(r, pts, npts, ePolyDefault);
  511.     Freea(tmppts);
  512. }
  513.  
  514. void WindowPort::DevStrokeWedge(int psz, GrLineCap cap, Rectangle *r, int s, int d)
  515. {
  516.     int rpsz= (psz <= 0) ? 1 : psz;
  517.     rpsz*= 2;
  518.     if (rpsz >= r->extent.x || rpsz >= r->extent.y) {
  519.     DevFillWedge(r, s, d);
  520.     return;
  521.     }
  522.     if (r->extent.x < 4 || r->extent.y < 4) {
  523.     DevStrokeRect(psz, r);
  524.     return;
  525.     }
  526.     if (cap & eStartArrow) {
  527.     DrawArrow(psz, r->OvalAngleToPoint(s+10), r->OvalAngleToPoint(s));
  528.     // s+= 10; d-= 10;
  529.     }
  530.     if (cap & eEndArrow) {
  531.     DrawArrow(psz, r->OvalAngleToPoint(s+d-10), r->OvalAngleToPoint(s+d));
  532.     // d-= 10;
  533.     }
  534.     DevStrokeWedge2(psz, cap, r, s, d);
  535. }
  536.  
  537. void WindowPort::DevFillWedge(Rectangle *r, int s, int d)
  538. {
  539.     if (r->extent.x < 4 || r->extent.y < 4)
  540.     DevFillRect(r);
  541.     else
  542.     DevFillWedge2(r, s, d);
  543. }
  544.  
  545. static void Wedge2Polygon(Point *pts, int &n, Point e2, float start, float len)
  546. {
  547.     if (len < 10)    // consider it a line
  548.     pts[n++]= PolarToPoint(start, e2.x, e2.y) + e2;
  549.     else {                  // subdivide
  550.     Wedge2Polygon(pts, n, e2, start, len/2);
  551.     Wedge2Polygon(pts, n, e2, start+len/2, len/2);
  552.     }
  553. }
  554.  
  555. void WindowPort::DevStrokeWedge2(int psz, GrLineCap cap, Rectangle *r, int start, int len)
  556. {
  557.     Point *pts= (Point*) Alloca(sizeof(Point) * len);
  558.     Point e2= (r->extent-psz)/2;
  559.     int n= 0;
  560.  
  561.     Wedge2Polygon(pts, n, e2, start, len);
  562.     pts[n++]= PolarToPoint(start+len, e2.x, e2.y) + e2;
  563.     r->origin+= psz/2;
  564.     DevStrokePolygon2(r, pts, n, ePolyDefault, psz, cap);
  565.     Freea(pts);
  566. }
  567.  
  568. void WindowPort::DevFillWedge2(Rectangle *r, int start, int len)
  569. {
  570.     Point *pts= (Point*) Alloca(sizeof(Point) * len);
  571.     Point e2= r->extent/2;
  572.     int n= 0;
  573.  
  574.     pts[n++]= e2;
  575.     Wedge2Polygon(pts, n, e2, start, len);
  576.     pts[n++]= PolarToPoint(start+len, e2.x, e2.y) + e2;
  577.     DevFillPolygon2(r, pts, n, ePolyDefault);
  578.     Freea(pts);
  579. }
  580.  
  581. void WindowPort::DevStrokeRRect(int psz, Rectangle *r, Point dia)
  582. {
  583.     int rpsz= (psz <= 0) ? 1 : psz;
  584.     
  585.     rpsz*= 2;
  586.     if (rpsz >= r->extent.x || rpsz >= r->extent.y) {
  587.     DevFillRRect(r, dia);
  588.     return;
  589.     }
  590.     if (ODD(dia.x))    // force to be even
  591.     dia.x--;
  592.     if (ODD(dia.y))    // force to be even
  593.     dia.y--;
  594.     
  595.     if (dia.x >= r->extent.x && dia.y >= r->extent.y)
  596.     DevStrokeOval(psz, r);
  597.     else
  598.     DevStrokeRRect2(psz, r, Min(dia, r->extent));
  599. }
  600.  
  601. void WindowPort::DevFillRRect(Rectangle *r, Point dia)
  602. {
  603.     if (ODD(dia.x % 1))    // force to be even
  604.     dia.x--;
  605.     if (ODD(dia.y % 1))    // force to be even
  606.     dia.y--;
  607.     
  608.     if (dia.x > r->extent.x && dia.y > r->extent.y)
  609.     DevFillOval(r);
  610.     else
  611.     DevFillRRect2(r, Min(dia, r->extent));
  612. }
  613.  
  614. void WindowPort::DevStrokeOval(int psz, Rectangle *r)
  615. {
  616.     int rpsz= (psz <= 0) ? 1 : psz;
  617.     
  618.     rpsz*= 2;
  619.     if (rpsz >= r->extent.x || rpsz >= r->extent.y)
  620.     DevFillOval(r);
  621.     else if (r->extent.x < 4 || r->extent.y < 4)
  622.     DevStrokeRect(psz, r);
  623.     else
  624.     DevStrokeOval2(psz, r);
  625. }
  626.  
  627. void WindowPort::DevFillOval(Rectangle *r)
  628. {
  629.     if (r->extent.x < 4 || r->extent.y < 4)
  630.     DevFillRect(r);
  631.     else
  632.     DevFillOval2(r);
  633. }
  634.  
  635. //---- abstract methods --------------------------------------------------------
  636.  
  637. void WindowPort::DevStrokeRect2(int, Rectangle*)
  638. {
  639.     AbstractMethod("DevStrokeRect2");
  640. }
  641.  
  642. void WindowPort::DevStrokeRRect2(int, Rectangle*, Point)
  643. {
  644.     AbstractMethod("DevStrokeRRect2");
  645. }
  646.  
  647. void WindowPort::DevFillRRect2(Rectangle*, Point)
  648. {
  649.     AbstractMethod("DevFillRRect2");
  650. }
  651.  
  652. void WindowPort::DevStrokePolygon2(Rectangle*, Point*, int, GrPolyType, int, GrLineCap)
  653. {
  654.     AbstractMethod("DevStrokePolygon2");
  655. }
  656.  
  657. void WindowPort::DevFillPolygon2(Rectangle*, Point*, int, GrPolyType)
  658. {
  659.     AbstractMethod("DevFillPolygon2");
  660. }
  661.  
  662. void WindowPort::DevStrokeLine2(int, Rectangle*, GrLineCap, Point, Point)
  663. {
  664.     AbstractMethod("DevStrokeLine2");
  665. }
  666.  
  667. void WindowPort::DevStrokeOval2(int psz, Rectangle *r)
  668. {
  669.     DevStrokeRRect2(psz, r, r->extent);
  670. }
  671.  
  672. void WindowPort::DevFillOval2(Rectangle *r)
  673. {
  674.     DevFillRRect2(r, r->extent);
  675. }
  676.  
  677. void WindowPort::DevSetCursor(GrCursor)
  678. {
  679.     AbstractMethod("DevSetCursor");
  680. }
  681.  
  682. void WindowPort::DevScrollRect(Rectangle, Point)
  683. {
  684.     AbstractMethod("DevScrollRect");
  685. }
  686.  
  687. void WindowPort::DevHide()
  688. {
  689.     AbstractMethod("DevHide");
  690. }
  691.  
  692. void WindowPort::DevShow(WindowPort*, Rectangle)
  693. {
  694.     AbstractMethod("DevShow");
  695. }
  696.  
  697. void WindowPort::DevGrab(bool, bool)
  698. {
  699.     AbstractMethod("DevGrab");
  700. }
  701.  
  702. void WindowPort::DevFullscreen(bool)
  703. {
  704.     AbstractMethod("DevFullScreen");
  705. }
  706.  
  707. void WindowPort::DevTop(bool)
  708. {
  709.     AbstractMethod("DevTop");
  710. };
  711.  
  712. void WindowPort::DevGetEvent(Token*, int, bool)
  713. {
  714.     AbstractMethod("DevGetEvent");
  715. };
  716.  
  717. void WindowPort::DevSetMousePos(Point, bool)
  718. {
  719.     AbstractMethod("DevSetMousePos");
  720. };
  721.  
  722. void WindowPort::DevBell(long)
  723. {
  724.     AbstractMethod("DevBell");
  725. }
  726.  
  727. void WindowPort::DevImageCacheEnd2(DevBitmap*, Rectangle*)
  728. {
  729. }
  730.  
  731. void WindowPort::DevImageCacheCopy2(DevBitmap*, Rectangle*, Point)
  732. {
  733. }
  734.  
  735. Rectangle WindowPort::DevGetRect()
  736. {
  737.     return gRect0;
  738. }
  739.  
  740. void WindowPort::DevSetExtent(Point)
  741. {
  742.     AbstractMethod("DevSetExtent");
  743. }
  744.  
  745. void WindowPort::DevSetOrigin(Point)
  746. {
  747.     AbstractMethod("DevSetOrigin");
  748. }
  749.  
  750. void WindowPort::DevSetTitle(char *name)
  751. {
  752. }
  753.